package com.mm.cloth;

import android.content.Intent;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.mm.cloth.api.ApiClient;
import com.mm.cloth.api.ApiService;
import com.mm.cloth.model.request.LoginRequest;
import com.mm.cloth.model.response.ApiResponse;
import com.mm.cloth.model.response.LoginResponse;
import com.mm.cloth.utils.LoginCheckUtil;
import com.mm.cloth.utils.NetworkUtil;
import com.mm.cloth.utils.TokenManager;
import com.mm.cloth.model.response.ServerLoginResponse;
import com.mm.cloth.utils.ResponseConverter;

import org.json.JSONObject;
import android.content.SharedPreferences;
import com.mm.cloth.api.ApiClient;

import okio.Buffer;

public class LoginActivity extends AppCompatActivity {
    private static final String TAG = "LoginActivity";
    
    private EditText etPhone;
    private EditText etPassword;
    private Button btnLogin;
    private TextView tvRegister;
    private TextView tvUserAgreement;
    private TextView tvPrivacyPolicy;
    private ProgressBar progressBar;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);
        
        Log.d(TAG, "onCreate: 检查是否从对话框启动: " + getIntent().getBooleanExtra("from_dialog", false));
        
        // 如果已经登录，直接进入主页
        if (TokenManager.isLoggedIn(this)) {
            navigateToMainActivity();
            return;
        }
        
        initViews();
        setupListeners();

        // 添加LoginRequest序列化测试

        // 额外测试：直接测试当前输入的参数
        testCurrentLoginRequestSerialization();

        // 如果有从注册页面传来的手机号，自动填充
        String phone = getIntent().getStringExtra("phone");
        if (!TextUtils.isEmpty(phone)) {
            etPhone.setText(phone);
        }
    }

    private void initViews() {
        etPhone = findViewById(R.id.etPhone);
        etPassword = findViewById(R.id.etPassword);
        btnLogin = findViewById(R.id.btnLogin);
        tvRegister = findViewById(R.id.tvRegister);
        tvUserAgreement = findViewById(R.id.tvUserAgreement);
        tvPrivacyPolicy = findViewById(R.id.tvPrivacyPolicy);
        progressBar = findViewById(R.id.progressBar);
        
        // 确保progressBar已经初始化
        if (progressBar == null) {
            Log.e(TAG, "progressBar not found in layout");
        }
    }

    private void setupListeners() {
        // 登录按钮点击事件
        btnLogin.setOnClickListener(v -> handleLogin());

        // 注册链接点击事件
        tvRegister.setOnClickListener(v -> {
            Intent intent = new Intent(LoginActivity.this, RegisterActivity.class);
            startActivity(intent);
        });

        // 用户协议点击事件
        tvUserAgreement.setOnClickListener(v -> {
            Toast.makeText(this, "用户协议", Toast.LENGTH_SHORT).show();
            // TODO: 跳转到用户协议页面
        });

        // 隐私政策点击事件
        tvPrivacyPolicy.setOnClickListener(v -> {
            Toast.makeText(this, "隐私政策", Toast.LENGTH_SHORT).show();
            // TODO: 跳转到隐私政策页面
        });
    }

    private void handleLogin() {
        String phone = etPhone.getText().toString().trim();
        String password = etPassword.getText().toString().trim();

        // 表单验证
        if (TextUtils.isEmpty(phone)) {
            Toast.makeText(this, "请输入手机号", Toast.LENGTH_SHORT).show();
            return;
        }

        if (TextUtils.isEmpty(password)) {
            Toast.makeText(this, "请输入密码", Toast.LENGTH_SHORT).show();
            return;
        }

        // 显示进度条
        if (progressBar != null) {
            progressBar.setVisibility(View.VISIBLE);
        }
        btnLogin.setEnabled(false);
        
        // 检查网络连接
        if (!NetworkUtil.isNetworkAvailable(this)) {
            Log.d(TAG, "网络不可用，尝试离线登录");
            handleOfflineLogin(phone, password);
            return;
        }

        // 调用登录API，设置超时处理
        Thread loginThread = new Thread(() -> {
            try {
                // 检查服务器是否可达
                String host = ApiClient.BASE_HOST;
                int port = ApiClient.BASE_PORT;
//                boolean isServerReachable = NetworkUtil.isHostReachable(host, port, 5000); // 2秒超时
//
//                if (!isServerReachable) {
//                    Log.d(TAG, "服务器不可达，尝试离线登录");
//                    runOnUiThread(() -> handleOfflineLogin(phone, password));
//                    return;
//                }
                
                // 服务器可达，继续常规登录流程
                runOnUiThread(() -> {
                    ApiService apiService = ApiClient.getInstance().getApiService();
                    LoginRequest loginRequest = new LoginRequest(phone, password);

                    // 添加调试日志，检查LoginRequest对象的内容
                    Log.d(TAG, "=== 登录请求调试信息 ===");
                    Log.d(TAG, "输入的手机号: "+ phone);
                    Log.d(TAG, "输入的密码: " + password);
                    Log.d(TAG, "LoginRequest对象 - phone: " + loginRequest.getUsername());
                    Log.d(TAG, "LoginRequest对象 - password: " + loginRequest.getPassword());

                    // 测试JSON序列化
                    com.google.gson.Gson gson = new com.google.gson.GsonBuilder()
                        .setLenient()
                        // 移除excludeFieldsWithoutExposeAnnotation限制，允许所有字段被序列化和反序列化
                        .create();
                    String jsonBody = gson.toJson(loginRequest);
                    Log.d(TAG, "序列化后的JSON: " + jsonBody);

                    // 检查JSON是否为空
                    if (jsonBody.equals("{}")) {
                        Log.e(TAG, "❌ 严重错误：JSON序列化结果为空对象！");
                        Log.e(TAG, "这表明LoginRequest的字段没有被正确序列化");
                    } else {
                        Log.d(TAG, "✅ JSON序列化成功，内容不为空");
                    }

                    apiService.login(loginRequest).enqueue(new retrofit2.Callback<ApiResponse<ServerLoginResponse>>() {
                        @Override
                        public void onResponse(retrofit2.Call<ApiResponse<ServerLoginResponse>> call,
                                             retrofit2.Response<ApiResponse<ServerLoginResponse>> response) {
                            // 隐藏进度条
                            if (progressBar != null) {
                                progressBar.setVisibility(View.GONE);
                            }
                            btnLogin.setEnabled(true);

                            if (response.isSuccessful() && response.body() != null) {
                                ApiResponse<ServerLoginResponse> apiResponse = response.body();

                                Log.d(TAG, "登录成功: " + new Gson().toJson(apiResponse));
                                if (apiResponse.getCode() == 200 && apiResponse.getData() != null) {
                                    // 将ServerLoginResponse转换为LoginResponse
                                    ServerLoginResponse serverResponse = apiResponse.getData();
                                    LoginResponse loginResponse = ResponseConverter.convertLoginResponse(serverResponse);
                                    
                                    if (loginResponse != null) {
                                        // 保存用户信息和令牌
                                        TokenManager.saveUserInfo(LoginActivity.this, loginResponse);

                                        // 同时保存到旧的LoginCheckUtil中，保持兼容性
                                        LoginCheckUtil.saveLoginState(LoginActivity.this, loginResponse.getToken(),
                                                "{\"phone\":\"" + phone + "\", \"name\":\"" + loginResponse.getNickname() + "\"}");

                                        // 登录成功，进入衣柜页面
                                        Log.d(TAG, "登录成功: " + loginResponse.getUsername());
                                        Toast.makeText(LoginActivity.this, "登录成功", Toast.LENGTH_SHORT).show();
                                        navigateToMainActivity();
                                    } else {
                                        // 转换失败
                                        Log.e(TAG, "登录响应转换失败");
                                        Toast.makeText(LoginActivity.this, "登录失败: 响应格式错误", Toast.LENGTH_SHORT).show();
                                    }
                                } else {
                                    // API返回错误
                                    String errorMsg = apiResponse.getMessage() != null ? apiResponse.getMessage() : "登录失败";
                                    Log.e(TAG, "登录失败: " + apiResponse.getCode() + " - " + errorMsg);

                                    // 如果是服务器错误，尝试离线登录
                                    if (apiResponse.getCode() >= 500) {
                                        handleOfflineLogin(phone, password);
                                    } else {
                                        Toast.makeText(LoginActivity.this, "登录失败: " + errorMsg, Toast.LENGTH_SHORT).show();
                                    }
                                }
                            } else {
                                // HTTP请求失败
                                Log.e(TAG, "登录请求失败: " + response.code());
                                if (response.code() >= 500) {
                                    handleOfflineLogin(phone, password);
                                } else {
                                    Toast.makeText(LoginActivity.this, "登录请求失败", Toast.LENGTH_SHORT).show();
                                }
                            }
                        }

                        @Override
                        public void onFailure(retrofit2.Call<ApiResponse<ServerLoginResponse>> call, Throwable t) {
                            // 隐藏进度条
                            if (progressBar != null) {
                                progressBar.setVisibility(View.GONE);
                            }
                            btnLogin.setEnabled(true);

                            Log.e(TAG, "登录网络错误: " + t.getMessage(), t);
                            // 网络错误时尝试离线登录
                            handleOfflineLogin(phone, password);
                        }
                    });
                });
            } catch (Exception e) {
                Log.e(TAG, "登录过程出现异常: " + e.getMessage(), e);
                runOnUiThread(() -> handleOfflineLogin(phone, password));
            }
        });
        
        // 启动登录线程
        loginThread.start();
        
        // 设置超时
        new Thread(() -> {
            try {
                // 等待5秒
                Thread.sleep(5000);
                if (loginThread.isAlive()) {
                    Log.w(TAG, "登录请求超时，尝试离线登录");
                    runOnUiThread(() -> handleOfflineLogin(phone, password));
                }
            } catch (InterruptedException e) {
                // 忽略中断异常
            }
        }).start();
    }
    
    /**
     * 处理离线登录模式
     * @param phone 手机号
     * @param password 密码
     */
    private void handleOfflineLogin(String phone, String password) {
        // 隐藏进度条
        if (progressBar != null) {
            progressBar.setVisibility(View.GONE);
        }
        btnLogin.setEnabled(true);
        
        // 检查是否有本地保存的用户信息
        SharedPreferences sp = getSharedPreferences("user_info", MODE_PRIVATE);
        String savedUserInfo = sp.getString("userInfo", null);
        String savedToken = sp.getString("token", null);
        
        if (savedUserInfo != null && savedToken != null) {
            try {
                // 尝试从保存的用户信息中解析手机号
                JSONObject userInfo = new JSONObject(savedUserInfo);
                String savedPhone = userInfo.optString("phone", "");
                
                if (!TextUtils.isEmpty(savedPhone) && savedPhone.equals(phone)) {
                    // 用户之前登录过，允许离线登录
                    Log.d(TAG, "离线登录成功: " + phone);
                    
                    // 设置离线模式标志
                    LoginCheckUtil.saveLoginState(this, savedToken, savedUserInfo);
                    
                    // 创建一个LoginResponse对象以便保存到TokenManager
                    try {
                        // 创建一个ServerLoginResponse对象
                        ServerLoginResponse serverResponse = new ServerLoginResponse();
                        serverResponse.setToken(savedToken);
                        
                        // 创建User对象并设置属性
                        ServerLoginResponse.User user = new ServerLoginResponse.User();
                        user.setUsername(userInfo.optString("name", "用户"));
                        user.setNickname(userInfo.optString("name", "用户"));
                        serverResponse.setUser(user);
                        
                        // 转换为LoginResponse
                        LoginResponse loginResponse = ResponseConverter.convertLoginResponse(serverResponse);
                        if (loginResponse != null) {
                            // 保存到TokenManager
                            TokenManager.saveUserInfo(this, loginResponse);
                            Log.d(TAG, "成功更新TokenManager登录状态");
                        } else {
                            Log.e(TAG, "离线登录响应转换失败");
                        }
                    } catch (Exception e) {
                        Log.e(TAG, "更新TokenManager登录状态失败: " + e.getMessage());
                    }
                    
                    Toast.makeText(this, "网络连接不可用，已启用离线模式", Toast.LENGTH_SHORT).show();
                    navigateToMainActivity();
                    return;
                }
            } catch (Exception e) {
                Log.e(TAG, "解析保存的用户信息失败: " + e.getMessage(), e);
            }
        }
        
        // 没有找到匹配的用户信息，或者出现异常
        Toast.makeText(this, "网络连接不可用，无法登录", Toast.LENGTH_SHORT).show();
    }
    
    /**
     * 登录成功后跳转到MainActivity
     */
    private void navigateToMainActivity() {
        try {
            // 检查是否来自对话框或个人页面
            boolean fromDialog = getIntent().getBooleanExtra("from_dialog", false);
            boolean fromProfile = getIntent().getBooleanExtra("from_profile", false);
            
            Log.d(TAG, "navigateToMainActivity: fromDialog=" + fromDialog + ", fromProfile=" + fromProfile);
            
            // 始终设置结果为成功，以便调用方能正确处理
            setResult(RESULT_OK);
            Log.d(TAG, "已设置结果码为RESULT_OK");
            
            if (fromDialog || fromProfile) {
                Log.d(TAG, "来自对话框或个人页面的登录，返回上一个页面");
                finish();
                return;
            }
            
            // 检查是否是通过startActivityForResult启动的
            if (getCallingActivity() != null) {
                // 是通过startActivityForResult启动的，设置结果码并返回
                Log.d(TAG, "通过startActivityForResult启动，设置结果并返回，CallingActivity=" + getCallingActivity().getClassName());
                finish();
                return;
            }
            
            // 直接跳转到MainActivity，它会显示WardrobeFragment
            Intent intent = new Intent(LoginActivity.this, MainActivity.class);
            // 添加标记，表示这是从登录页面跳转过来的，避免循环检查登录状态
            intent.putExtra("from_login", true);
            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
            startActivity(intent);
            finish(); // 关闭登录页面
        } catch (Exception e) {
            Log.e(TAG, "启动MainActivity失败: " + e.getMessage(), e);
            Toast.makeText(this, "启动主页面失败", Toast.LENGTH_SHORT).show();
        }
    }

    /**
     * 测试当前输入的登录请求序列化
     */
    private void testCurrentLoginRequestSerialization() {
        Log.d(TAG, "=== 测试当前输入的登录请求序列化 ===");

        // 获取当前输入的值
        String currentPhone = etPhone.getText().toString().trim();
        String currentPassword = etPassword.getText().toString().trim();

        Log.d(TAG, "当前输入 - 手机号: '" + currentPhone + "'");
        Log.d(TAG, "当前输入 - 密码: '" + currentPassword + "'");

        // 创建LoginRequest对象
        com.mm.cloth.model.request.LoginRequest loginRequest =
            new com.mm.cloth.model.request.LoginRequest(currentPhone, currentPassword);

        Log.d(TAG, "LoginRequest对象 - getPhone(): '" + loginRequest.getUsername() + "'");
        Log.d(TAG, "LoginRequest对象 - getPassword(): '" + loginRequest.getPassword() + "'");

        // 测试JSON序列化
        com.google.gson.Gson gson = new com.google.gson.GsonBuilder()
            .setPrettyPrinting()
            .setLenient()
            .excludeFieldsWithoutExposeAnnotation() // 与ApiClient保持一致
            .create();
        String json = gson.toJson(loginRequest);

        Log.d(TAG, "序列化后的JSON:");
        Log.d(TAG, json);

        // 检查JSON内容
        if (json.equals("{}")) {
            Log.e(TAG, "❌ 严重错误：JSON序列化结果为空对象！");
            Log.e(TAG, "这表明LoginRequest的字段没有被正确序列化");
            Log.e(TAG, "可能的原因：");
            Log.e(TAG, "1. @SerializedName注解被混淆工具移除");
            Log.e(TAG, "2. 字段名被混淆");
            Log.e(TAG, "3. Gson配置问题");
        } else if (json.contains("\"phone\"") && json.contains("\"password\"")) {
            Log.d(TAG, "✅ JSON序列化成功，包含phone和password字段");
        } else {
            Log.w(TAG, "⚠️ JSON序列化部分成功，但可能缺少某些字段");
        }

        Log.d(TAG, "=== 测试完成 ===");
    }
}